/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pRoot TreeNode类
     * @return bool布尔型
     */
    int gethight(TreeNode* node)
    {
        if(node==nullptr)
        {
            return 0;
        }
        int leftTreeHight=gethight(node->left);
        int rightTreeHight=gethight(node->right);
        return max(leftTreeHight,rightTreeHight)+1;
    }
    bool IsBalanced_Solution(TreeNode* pRoot) {
        if(pRoot==nullptr)
        {
            return true;
        }
        int left=gethight(pRoot->left);
        int right=gethight(pRoot->right);
        if(abs(left-right)>1)
        {
            return false;
        }
        return IsBalanced_Solution(pRoot->left)&&IsBalanced_Solution(pRoot->right);
    }
};

// #include <iostream>
// #include <queue>
// #include <cmath>

// using namespace std;

// // 二叉树节点结构体定义
// struct TreeNode {
//     int val;
//     struct TreeNode *left;
//     struct TreeNode *right;
//     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
// };

// class Solution {
// public:
//     // 计算二叉树的高度
//     int getHeight(TreeNode* node) {
//         if (node == nullptr) {
//             return 0;
//         }
//         // 递归计算左子树高度
//         int leftHeight = getHeight(node->left);
//         // 递归计算右子树高度
//         int rightHeight = getHeight(node->right);

//         // 返回左右子树中较大高度加1（当前节点高度）
//         return max(leftHeight, rightHeight) + 1;
//     }

//     // 判断二叉树是否为平衡二叉树
//     bool IsBalanced_Solution(TreeNode* pRoot) {
//         if (pRoot == nullptr) {
//             return true;
//         }

//         // 计算左子树高度
//         int leftHeight = getHeight(pRoot->left);
//         // 计算右子树高度
//         int rightHeight = getHeight(pRoot->right);

//         // 检查当前节点的左右子树高度差是否满足平衡条件
//         if (abs(leftHeight - rightHeight) > 1) {
//             return false;
//         }

//         // 递归判断左子树和右子树是否也为平衡二叉树
//         return IsBalanced_Solution(pRoot->left) && IsBalanced_Solution(pRoot->right);
//     }
// };



#include<iostream>
#include<algorithm>
using namespace std;
const int N = 110;
int t[N][N];

int main() {
    int n;
    cin >> n;
    // 初始化边界
    for (int j = 1; j <= n; j++) {
        t[0][j] = 0;
    }
    for (int i = 1; i <= n; i++) {
        t[i][0] = 0;
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            int x;
            cin >> x;
            t[i][j] = t[i - 1][j] + t[i][j - 1] - t[i - 1][j - 1] + x;
        }
    }
    int ret = -1e9;
    for (int x1 = 1; x1 <= n; x1++) {
        for (int y1 = 1; y1 <= n; y1++) {
            for (int x2 = x1; x2 <= n; x2++) {
                for (int y2 = y1; y2 <= n; y2++) {
                    int sum = t[x2][y2] - t[x1 - 1][y2] - t[x2][y1 - 1] + t[x1 - 1][y1 - 1];
                    ret = max(ret, sum);
                }
            }
        }
    }
    cout << ret;
    return 0;
}

#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

int main() {
    int n;
    cin >> n;
    string s;
    cin >> s;
    unordered_map<char,int> mp;
    for(int i=0;i<s.size();i++)
    {
        mp[s[i]]++;
    }
    int sum=0;
    int left=0,right=0;
    int c[2]={0};
    while(right<n-1)
    {
        c[s[right]-'0']++;
        if((right-left+1)>(n/2))
        {
            c[s[left++]-'0']--;
        }
        if((right-left+1)==(n/2))
        {
            if(2*c[0]==mp['0']&&2*c[1]==mp['1'])
            {
                sum++;
            }
        }
        right++;
    }
    cout << sum*2;
    return 0;
}